home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 1 / PC World Interactive 1 - Nisan 1997.iso / prog / graf / 5 / _001250_ < prev    next >
Text File  |  1996-06-04  |  15KB  |  390 lines
  1. //------------------------------------------------------------------------------------------------------
  2. // Name       : export_.c
  3. // Date       : 23.05.1996     Author : SM           System : Win32
  4. //------------------------------------------------------------------------------------------------------
  5. // This file contains the language-independent implementation of the module EXPORT_.DLL. All texts and
  6. // resources that are language-dependent are located in an additional EXPORT.DLL, whose sources can be
  7. // found in the subdirectories \E (for English) and \D (for German).
  8. //------------------------------------------------------------------------------------------------------
  9.  
  10. #define USER_DATA_ID          "1.00-1995-08-10"
  11.  
  12. //------------------------------------------------------------------------------------------------------
  13.  
  14. #include        "windows.h"
  15. #include        "windowsx.h"
  16. #include        "stdlib.h"
  17. #include        "stdio.h"
  18. #include        "math.h"
  19.  
  20. #include        "e:\release4\toso40.h"          // Toso Interface 4.0 Definitions
  21. #include        "dialog.h"
  22.  
  23. //------------------------------------------------------------------------------------------------------
  24.  
  25. typedef struct {
  26.   STR32         TimeStamp;
  27.  
  28.   FILENAME      FileName;
  29. } INF_HEADER;
  30.  
  31. //------ Language-dependent texts in EXPORT.DLL --------------------------------------------------------
  32.  
  33. DLL_IMPORT LPSTR
  34.         eStartUpText    [],
  35.         eDefaultName    [],
  36.         eDialogText     [],
  37.         eMessageText    [];
  38.  
  39. //------------------------------------------------------------------------------------------------------
  40.  
  41. static  HINSTANCE       hInstDLL,               // Instance handle of the main DLL
  42.                         hLanguage,              // Instance handle of the language DLL
  43.                         hGlobalInst;            // Instance handle of the serving application
  44. static  HWND            hGlobalWnd;             // Main window handle of the serving application
  45.  
  46. //------------------------------------------------------------------------------------------------------
  47.  
  48. static  HBITMAP         hBitmap;
  49. static  INF_HEADER      INFHeader;
  50. static  int             gError;                 // Current error status ( 0 = OK )
  51.  
  52. //------------------------------------------------------------------------------------------------------
  53.  
  54. BOOL ModuleLoadSettings( void )
  55. {
  56.   BOOL          Result = FALSE;
  57.  
  58.   if( TosoProfileReadKeyOpen( "EXPORT", FALSE ) ) {
  59.     if( TosoProfileReadData( "Init", (LPBYTE) &INFHeader, sizeof( INFHeader ) ) )
  60.       Result = TRUE;
  61.     TosoProfileReadKeyClose();
  62.  
  63.     INFHeader.TimeStamp[31] = 0x00;
  64.     if( lstrcmp( INFHeader.TimeStamp, USER_DATA_ID ) )
  65.       Result = FALSE;
  66.   }
  67.  
  68.   if( !Result ) {
  69.     lstrcpy( INFHeader.FileName, eDefaultName[0] );
  70.   }
  71.   return( Result );
  72. }
  73.  
  74. //------------------------------------------------------------------------------------------------------
  75.  
  76. BOOL ModuleSaveSettings( void )
  77. {
  78.   BOOL          Result = FALSE;
  79.  
  80.   if( TosoProfileWriteKeyOpen( "EXPORT", FALSE ) ) {
  81.     lstrcpy( INFHeader.TimeStamp, USER_DATA_ID );
  82.     if( TosoProfileWriteData( "Init", (LPBYTE) &INFHeader, sizeof( INFHeader ) ) )
  83.       Result = TRUE;
  84.     TosoProfileWriteKeyClose();
  85.   }
  86.   return( Result );
  87. }
  88.  
  89. //------------------------------------------------------------------------------------------------------
  90. // This procedure is used as callback procedure for an object enumeration based on the interface
  91. // procedure TosoEnumerateAll(). It simply runs through of the object described in EnumData and write
  92. // the coordinates of all its definition points to the currently open file.
  93. // After each coordinate pair written, it also updates the current progress indicator and checks whether
  94. // the user has pressed the Cancel button to stop the export.
  95.  
  96. BOOL ModuleEnumCallback( const ENUMDEF_DATA* EnumData )
  97. {
  98.   DUMMYSTR      Text1, Text2;
  99.   int           Count;
  100.  
  101.   switch( EnumData->EnumData ) {
  102.     case ENUMDATA_CURVE:
  103.     case ENUMDATA_AREA:
  104.     case ENUMDATA_MARK:
  105.       for( Count = 0; Count < EnumData->EnumCount; Count++ ) {
  106.         TosoFileWriteShort      ( DB_POINT_ANY );
  107.         TosoFileWriteCommaDouble( EnumData->PointPtr[Count].x );
  108.         TosoFileWriteCommaDouble( EnumData->PointPtr[Count].y );
  109.         TosoFileWriteSemi();
  110.  
  111.         if( TosoFileWriteError() ) {
  112.           gError = 1;
  113.           break;
  114.         }
  115.  
  116.         wsprintf( Text1, eDialogText[3], TosoFileWriteCurrentLine() );
  117.         wsprintf( Text2, eDialogText[4], ( TosoFileWriteCurrentSize() + 1023 ) / 1024 );
  118.         TosoDialogUpdateProgress( Text1, Text2, NOPARAM, NOPARAM );
  119.  
  120.         if( TosoDialogIsCanceled() ) {
  121.           gError = 999;
  122.           break;
  123.         }
  124.       }
  125.       break;
  126.   }
  127.   return( !gError );
  128. }
  129.  
  130. //------------------------------------------------------------------------------------------------------
  131. // This procedure performs the export. It starts the object enumeration (which writes coordinate pairs
  132. // to the file).
  133. // In addition, it initializes and display a progress indicator window to inform the user about the
  134. // current progress and to allow him to cancel the export. Since the final file size is not known
  135. // in advance, the progress indicator does not include a percent bar.
  136.  
  137. void ModuleExport( HANDLE FileHandle, const LPSTR FileName )
  138. {
  139.   FILENAME      FileName2;
  140.   DUMMYSTR      DummyStr;
  141.  
  142.   gError = 0;
  143.  
  144.   if( !TosoFileWriteInitDisk( FileHandle ) ) {
  145.     gError = 1;
  146.     return;
  147.   }
  148.  
  149.   TosoFileSplitName( FileName, NULL, FileName2 );
  150.   wsprintf( DummyStr, eDialogText[2], FileName2 );
  151.   TosoDialogShowProgress( eDialogText[0], DummyStr, FALSE );
  152.  
  153.   TosoEnumerateAll( TosoDrawingGetActive(), FLAG_USE, FLAG_USE,
  154.                     ENUMMODE_PLAIN | ENUMMODE_LINES | ENUMMODE_LINETYPES,
  155.                     (TOSOENUMOBJECT_PROC) ModuleEnumCallback );
  156.  
  157.   TosoFileWriteShort( DB_END );
  158.   TosoFileWriteSemi();
  159.  
  160.   if( !TosoFileWriteFlush() )
  161.     gError = 1;
  162.  
  163.   TosoFileWriteExit();
  164.   TosoDialogHideProgress();
  165. }
  166.  
  167. //------------------------------------------------------------------------------------------------------
  168. // This DLL entry procedure must exist in any DLL to be used in Win32. Since our DLL does all necessary
  169. // initialization in its TosoModuleInit() procedure, this procedure is quite empty.
  170.  
  171. BOOL WINAPI DllMain( HINSTANCE hInstance, DWORD Reason, LPVOID Dummy )
  172. {
  173.   switch( Reason ) {
  174.     case DLL_PROCESS_ATTACH:
  175.       hInstDLL = hInstance;
  176.       break;
  177.  
  178.     case DLL_PROCESS_DETACH:
  179.       hInstDLL = NULL;
  180.       break;
  181.   }
  182.   return( TRUE );
  183. }
  184.  
  185. //------------------------------------------------------------------------------------------------------
  186. // This procedure is called when the module is loaded by the serving application. Its main tasks are:
  187. // - Checking whether it is compatible with the given InterfaceVersion
  188. // - Checking whether it is licensed to the given serial number (optional)
  189. // - Storing of the serving application's instance and main windows handle for further use
  190. // - Loading of the language-dependent library
  191. // - Filling in the module ID structure whose address is passed in ModuleID
  192. // - Loading of options from the registry database
  193. // - Loading profiles
  194. // - Allocating any static memory required
  195.  
  196. DLL_EXPORT BOOL TosoModuleInit( const LPSTR SerialNumber, HINSTANCE hMainInst, HWND hMainWnd,
  197.                                                           int InterfaceVersion, MODULE_ID* ModuleID )
  198. {
  199.   if( InterfaceVersion < TOSO_INTERFACE_VERSION ) {
  200.     MessageBox( hMainWnd, eMessageText[0], eDialogText[0], MB_OK );
  201.     return( FALSE );
  202.   }
  203.  
  204.   if( !lstrcmp( SerialNumber, "DEMO" ) )
  205.     return( FALSE );
  206.  
  207.   hGlobalInst = hMainInst;
  208.   hGlobalWnd  = hMainWnd;
  209.  
  210.   hLanguage = LoadLibrary( "EXPORT.DLL" );
  211.   hBitmap = LoadBitmap( hLanguage, "IDB_COMMAND" );
  212.  
  213.   ModuleID->OwnerID    = DB_OWNER_TOSO;
  214.   ModuleID->ModuleID   = 0x2000;
  215.   ModuleID->ModuleCTRL = MODULECTRL_ALL;
  216.  
  217.   ModuleID->ModuleProc.InputPointInitProc = (TOSOINPUTPOINTINIT_PROC) NULL;
  218.   ModuleID->ModuleProc.InputPointMoveProc = (TOSOINPUTPOINTMOVE_PROC) NULL;
  219.   ModuleID->ModuleProc.InputPointExitProc = (TOSOINPUTPOINTEXIT_PROC) NULL;
  220.   ModuleID->ModuleProc.InputDisplayProc   = (TOSOINPUTDISPLAY_PROC)   NULL;
  221.   ModuleID->ModuleProc.InputParameterProc = (TOSOINPUTPARAMETER_PROC) NULL;
  222.   ModuleID->ModuleProc.InputCancelProc    = (TOSOINPUTCANCEL_PROC)    NULL;
  223.   ModuleID->ModuleProc.InputFinishProc    = (TOSOINPUTFINISH_PROC)    NULL;
  224.  
  225.   ModuleID->ModuleData.Type = MODULETYPE_EXPORT;
  226.  
  227.   ModuleID->ModuleData.InputData.CommandMode = COMMAND_DIRECT;
  228.   ModuleID->ModuleData.MenuData.MenuEntry   = eStartUpText[1];
  229.   ModuleID->ModuleData.MenuData.Description = eStartUpText[2];
  230.  
  231.   ModuleID->ModuleData.IconHandle  = hBitmap;
  232.   ModuleID->ModuleData.IconXOffset = 0;
  233.   ModuleID->ModuleData.IconYOffset = 0;
  234.   ModuleID->ModuleData.IconMode    = 0;
  235.  
  236.   ModuleID->CommandData = NULL;
  237.  
  238.   ModuleLoadSettings();
  239.  
  240.   return( TRUE );
  241. }
  242.  
  243. //------------------------------------------------------------------------------------------------------
  244. // This procedure is called when the module is removed by the serving application. Its main tasks are:
  245. // - Checking whether anything is to be saved. If so, it should display a message information the user
  246. //   about it and allowing him to save those changes.
  247. // - Freeing of all statically allocated memory.
  248. // If this procedure return FALSE, the serving application will not be able to terminate. So please, do
  249. // only return FALSE if shutting down the module now would severely damage or destroy user data.
  250.  
  251. DLL_EXPORT BOOL TosoModuleExit( void )
  252. {
  253.   ModuleSaveSettings();
  254.  
  255.   DeleteBitmap( hBitmap );
  256.  
  257.   return( TRUE );
  258. }
  259.  
  260. //------------------------------------------------------------------------------------------------------
  261. // This procedure serves as hook procedure for the comman file open dialog window. It manages the Infos
  262. // button that has been added to the standard GetSaveFileName dialog template.
  263. // In a more sophisticated export module, the common dialog would also contain a Options button which
  264. // would also be managed in this procedure.
  265.  
  266. UINT CALLBACK TosoModuleGetFileNameHook( HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam )
  267. {
  268.   switch( message ) {
  269.     case WM_INITDIALOG:                                 // Initialize dialog box
  270.       TosoDialogCenter( hDlg );                         // Center dialog window
  271.       return( 1 );
  272.  
  273.     case WM_COMMAND:
  274.       switch( GET_WM_COMMAND_ID( wParam, lParam ) ) {
  275.         case IDD_BUTTON0:                               // Infos
  276.           MessageBox( hDlg, eStartUpText[0], eDialogText[0], MB_OK );
  277.           return( 1 );
  278.       }
  279.       break;
  280.  
  281.     case WM_ENTERIDLE:
  282.       return( TosoDialogEnterIdle( hDlg, wParam, lParam ) );
  283.  
  284.     default:
  285.       if( message == TosoDialogHelpMessage() ) {
  286.         WinHelp( hDlg, "EXPORT.HLP", HELP_CONTEXT, 1 );
  287.         return( 1 );
  288.       }
  289.       break;
  290.   }
  291.   return( 0 );                                          // Didn't process a message
  292. }
  293.  
  294. //------------------------------------------------------------------------------------------------------
  295. // This procedure is called when a module's command is chosen by the user. For an export filter, its
  296. // main tasks are:
  297. // - Prompting the user for the file name of the export file. This should usually be done by means of
  298. //   common dialog windows extended by some additional buttons like Infos and Options
  299. // - Opening the export file
  300. // - Calling the basic export procedure
  301. // - Closing the export file
  302. // - Error handling and display
  303.  
  304. DLL_EXPORT BOOL TosoModuleCommand( int CommandID, int ExecMode )
  305. {
  306.   static  OPENFILENAME  OpenData;
  307.   static  FILENAME      FileName;
  308.   HANDLE                FileHandle;
  309.   DUMMYSTR              DummyStr;
  310.   DWORD                 CmnDlgError;
  311.   BOOL                  Result = FALSE;
  312.  
  313.   if( CommandID != 0 )
  314.     return( FALSE );
  315.  
  316. // Check whether a help topic is to be displayed instead of starting a command.
  317.  
  318.   if( ExecMode == MODULEEXEC_HELP ) {
  319.     WinHelp( hGlobalWnd, "EXPORT.HLP", HELP_CONTEXT, 1 );
  320.     return( FALSE );
  321.   }
  322.  
  323.   lstrcpy( FileName, INFHeader.FileName );
  324.  
  325.   OpenData.lStructSize       = sizeof( OPENFILENAME );
  326.   OpenData.hwndOwner         = hGlobalWnd;
  327.   OpenData.hInstance         = hLanguage;
  328.   OpenData.lpstrFilter       = eDialogText[1];
  329.   OpenData.lpstrCustomFilter = NULL;
  330.   OpenData.nMaxCustFilter    = 0;
  331.   OpenData.nFilterIndex      = 1;
  332.   OpenData.lpstrFile         = FileName;
  333.   OpenData.nMaxFile          = sizeof( FileName );
  334.   OpenData.lpstrFileTitle    = NULL;
  335.   OpenData.nMaxFileTitle     = 0;
  336.   OpenData.lpstrInitialDir   = NULL;
  337.   OpenData.lpstrTitle        = eDialogText[0];
  338.   OpenData.Flags             = OFN_HIDEREADONLY | OFN_NONETWORKBUTTON | OFN_SHOWHELP |
  339.                                OFN_ENABLEHOOK | OFN_ENABLETEMPLATE | OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
  340.   OpenData.nFileOffset       = 0;
  341.   OpenData.nFileExtension    = 0;
  342.   OpenData.lpstrDefExt       = eDefaultName[2];
  343.   OpenData.lCustData         = NOPARAM;
  344.   OpenData.lpfnHook          = (LPOFNHOOKPROC) TosoModuleGetFileNameHook;
  345.   OpenData.lpTemplateName    = "GETFILENAME";
  346.  
  347.   Result = GetSaveFileName( &OpenData );                // Open common dialog window
  348.  
  349.   if( !Result )                                         // TRUE=OK, FALSE=cancel or error
  350.     CmnDlgError = CommDlgExtendedError();               // 0=cancel, else error number
  351.  
  352.   if( !Result ) {                                       // Cancel
  353.     if( CmnDlgError ) {                                 // Error in common dialog
  354.       wsprintf( DummyStr, eMessageText[3], CmnDlgError );
  355.       MessageBox( hGlobalWnd, DummyStr, eDialogText[0], MB_OK );
  356.     }
  357.     return( TRUE );
  358.   }
  359.   else                                                  // Store the selected file name
  360.     lstrcpy( INFHeader.FileName, FileName );
  361.  
  362.   Result = FALSE;
  363.   SetCursor( LoadCursor( NULL, IDC_WAIT ) );
  364.  
  365.   if( TosoFileCreate( &FileHandle, FileName ) ) {
  366.  
  367.     ModuleExport( FileHandle, FileName );
  368.  
  369.     TosoFileClose( FileHandle );
  370.     switch( gError ) {
  371.       case 999:
  372.         TosoFileDelete( FileName );
  373.         MessageBox( hGlobalWnd, eMessageText[2], eDialogText[0], MB_OK );
  374.         Result = TRUE;
  375.         break;
  376.  
  377.       case 0:
  378.         Result = TRUE;
  379.         break;
  380.  
  381.       default:
  382.         TosoFileDelete( FileName );
  383.         MessageBox( hGlobalWnd, eMessageText[4], eDialogText[0], MB_OK );
  384.         Result = FALSE;
  385.         break;
  386.     }
  387.   }
  388.   return( Result );
  389. }
  390.